// 认证相关的工具函数 - 专注于本地认证状态管理
/**
 * 工具层职责说明：
 * 1. 负责Token和用户信息的本地存储与读取
 * 2. 提供登录状态检查、权限验证等功能
 * 3. 管理用户信息的标准化和兼容性处理
 * 4. API调用请移至api/auth.js中实现
 */

/**
 * 性别转换辅助函数 - 将字符串转换为数字类型
 * @param {string} genderStr - 性别字符串(male/female)
 * @returns {number} 1表示男，2表示女，其他值返回0
 */
export function convertGenderToNumber(genderStr) {
  if (genderStr === 'male') return 1;
  if (genderStr === 'female') return 2;
  return 0;
}

/**
 * 性别转换辅助函数 - 将数字转换为字符串类型
 * @param {number} genderNum - 性别数字(1/2)
 * @returns {string} male表示男，female表示女
 */
export function convertGenderToString(genderNum) {
  return genderNum === 1 ? 'male' : 'female';
}

/**
 * 保存Token
 * @param {string} token - JWT Token
 * @returns {boolean} 是否保存成功
 */
export function saveToken(token) {
  try {
    console.log('开始保存Token');
    
    // 检查token是否存在且为字符串
    if (!token || typeof token !== 'string') {
      console.error('Token保存失败: 无效的Token值');
      return false;
    }
    
    uni.setStorageSync('token', token);
    console.log('Token保存成功');
    return true;
  } catch (e) {
    console.error('存储Token失败:', e.message || e);
    return false;
  }
}

/**
 * 获取Token
 * @returns {string} Token
 */
export function getToken() {
  try {
    return uni.getStorageSync('token') || '';
  } catch (e) {
    console.error('获取Token失败:', e);
    return '';
  }
}

/**
 * 清除Token
 */
export function clearToken() {
  try {
    uni.removeStorageSync('token');
    return true;
  } catch (e) {
    console.error('清除Token失败:', e);
    return false;
  }
}

/**
 * 保存用户信息 - 分离存储模式
 * @param {Object} userInfo - 用户信息
 * @returns {boolean} 是否保存成功
 */
export function saveUserInfo(userInfo) {
  try {
    console.log('开始保存用户信息:', userInfo);
    
    // 检查用户信息是否存在
    if (!userInfo || typeof userInfo !== 'object') {
      console.error('用户信息保存失败: 无效的用户信息对象');
      return false;
    }
    
    // 根据后端数据库设计，分离存储用户信息
    
    // 保存基础用户信息 (对应 user 表)
    const baseUserInfo = {
      id: userInfo.id || '',
      openid: userInfo.openid || '',
      wechat_name: userInfo.wechat_name || userInfo.nickname || '',
      wechat_avatar: userInfo.wechat_avatar || userInfo.avatar_url || '',
      phone: userInfo.phone || '',
      role: userInfo.role || 0, // 使用后端的数字类型
      status: userInfo.status || 1,
      create_time: userInfo.create_time || '',
      update_time: userInfo.update_time || ''
    };
    
    uni.setStorageSync('baseUserInfo', baseUserInfo);
    console.log('基础用户信息保存成功');
    
    // 根据用户类型保存特定信息
    const userType = userInfo.role || userInfo.user_type;
    console.log('用户类型:', userType);
    
    if (userType === 'patient' || userType === 2) {
      // 保存患者信息 (对应 user_patient 表)
      const patientInfo = {
        user_id: userInfo.id || '',
        gender: convertGenderToNumber(userInfo.gender) || 1, // 转换为后端的数字类型
        age: parseInt(userInfo.age) || 0,
        id_card: userInfo.id_card || userInfo.idCard || ''
      };
      uni.setStorageSync('patientInfo', patientInfo);
      console.log('患者信息保存成功');
    } else if (userType === 'doctor' || userType === 1) {
      // 保存医生信息 (对应 user_doctor 表)
      const doctorInfo = {
        user_id: userInfo.id || '',
        real_name: userInfo.real_name || '', // ✅ 添加真实姓名
        hospital: userInfo.hospital || '',
        department: userInfo.department || '',
        position: userInfo.position || ''
      };
      uni.setStorageSync('doctorInfo', doctorInfo);
      console.log('医生信息保存成功（包含姓名）:', doctorInfo);
    }
    
    // 构建兼容前端的完整用户信息对象
    const compatibleUserInfo = {
      // 基础信息
      id: baseUserInfo.id,
      phone: baseUserInfo.phone,
      role: baseUserInfo.role,
      status: baseUserInfo.status,
      create_time: baseUserInfo.create_time,
      update_time: baseUserInfo.update_time,
      // 微信相关信息，增加兼容性
      openid: baseUserInfo.openid,
      nickname: baseUserInfo.wechat_name,
      avatar_url: baseUserInfo.wechat_avatar,
      wechat_name: baseUserInfo.wechat_name,
      wechat_avatar: baseUserInfo.wechat_avatar
    };
    
    // 根据用户类型添加特定信息
    if (userType === 'patient' || userType === 2) {
      const patientInfo = uni.getStorageSync('patientInfo') || {};
      compatibleUserInfo.gender = convertGenderToString(patientInfo.gender || 1);
      compatibleUserInfo.age = patientInfo.age || 0;
      compatibleUserInfo.id_card = patientInfo.id_card || '';
      compatibleUserInfo.idCard = patientInfo.id_card || ''; // 兼容旧字段名
      compatibleUserInfo.user_type = 'patient';
    } else if (userType === 'doctor' || userType === 1) {
      const doctorInfo = uni.getStorageSync('doctorInfo') || {};
      compatibleUserInfo.real_name = doctorInfo.real_name || ''; // ✅ 添加真实姓名
      compatibleUserInfo.hospital = doctorInfo.hospital || '';
      compatibleUserInfo.department = doctorInfo.department || '';
      compatibleUserInfo.position = doctorInfo.position || '';
      compatibleUserInfo.user_type = 'doctor';
    }
    
    // 保存完整用户信息，确保现有代码兼容性
    // 修复：setStorageSync是同步方法，不应该使用await
    uni.setStorageSync('userInfo', compatibleUserInfo);
    console.log('完整用户信息保存成功:', compatibleUserInfo);
    
    return true;
  } catch (e) {
    console.error('存储用户信息失败:', e.message || e);
    return false;
  }
}

/**
 * 获取用户信息 - 支持分离存储模式
 * @returns {Object} 用户信息
 */
export function getUserInfoLocal() {
  try {
    // 优先从完整用户信息中获取，保持向后兼容
    const completeUserInfo = uni.getStorageSync('userInfo') || {}
    
    // 如果存在完整用户信息，直接返回
    if (Object.keys(completeUserInfo).length > 0) {
      return completeUserInfo
    }
    
    // 否则从分离存储中构建用户信息
    const baseUserInfo = uni.getStorageSync('baseUserInfo') || {}
    const userType = baseUserInfo.role
    
    // 构建基础用户信息
    const userInfo = {
      id: baseUserInfo.id || '',
      openid: baseUserInfo.openid || '',
      wechat_name: baseUserInfo.wechat_name || '',
      wechat_avatar: baseUserInfo.wechat_avatar || '',
      phone: baseUserInfo.phone || '',
      role: baseUserInfo.role || 0,
      status: baseUserInfo.status || 1,
      create_time: baseUserInfo.create_time || '',
      update_time: baseUserInfo.update_time || '',
      // 兼容前端字段
      nickname: baseUserInfo.wechat_name || '',
      avatar_url: baseUserInfo.wechat_avatar || ''
    }
    
    // 根据用户类型添加特定信息
    if (userType === 2) {
      // 患者信息
      const patientInfo = uni.getStorageSync('patientInfo') || {}
      userInfo.gender = convertGenderToString(patientInfo.gender || 1)
      userInfo.age = patientInfo.age || 0
      userInfo.id_card = patientInfo.id_card || ''
      userInfo.idCard = patientInfo.id_card || '' // 兼容旧字段名
      userInfo.user_type = 'patient'
    } else if (userType === 1) {
      // 医生信息
      const doctorInfo = uni.getStorageSync('doctorInfo') || {}
      userInfo.real_name = doctorInfo.real_name || '' // ✅ 添加真实姓名
      userInfo.hospital = doctorInfo.hospital || ''
      userInfo.department = doctorInfo.department || ''
      userInfo.position = doctorInfo.position || ''
      userInfo.user_type = 'doctor'
    }
    
    return userInfo
  } catch (e) {
    console.error('获取用户信息失败:', e)
    return {}
  }
}

/**
 * 清除用户信息 - 支持分离存储模式
 */
export function clearUserInfo() {
  try {
    // 清除分离存储的用户信息
    uni.removeStorageSync('baseUserInfo')
    uni.removeStorageSync('patientInfo')
    uni.removeStorageSync('doctorInfo')
    
    // 保留清除原有用户信息，保持兼容性
    uni.removeStorageSync('userInfo')
    
    return true
  } catch (e) {
    console.error('清除用户信息失败:', e)
    return false
  }
}

/**
 * 保存登录状态 - 支持分离存储模式
 * @param {boolean} isLoggedIn - 是否已登录
 * @param {string|number} [userType] - 用户类型
 * @param {Object} [userInfo] - 用户信息
 * @returns {boolean} 是否保存成功
 */
export function saveLoginStatus(isLoggedIn, userType, userInfo) {
  try {
    uni.setStorageSync('isLoggedIn', isLoggedIn)
    
    // 如果提供了用户类型，也保存用户类型
    if (userType !== undefined) {
      uni.setStorageSync('userType', userType)
    }
    
    // 如果提供了用户信息，也保存用户信息
    if (userInfo !== undefined) {
      saveUserInfo(userInfo)
    }
    
    return true
  } catch (e) {
    console.error('存储登录状态失败:', e)
    return false
  }
}

/**
 * 获取登录状态 - 支持数字类型角色字段
 * @returns {Object} 登录状态信息
 */
export function getLoginStatus() {
  try {
    const isLoggedIn = uni.getStorageSync('isLoggedIn')
    const userInfo = getUserInfoLocal()
    const token = getToken()
    
    // 优先从本地存储获取 userType（登录时保存的）
    let userType = uni.getStorageSync('userType')
    
    // 如果本地存储没有，则根据 role 判断
    if (!userType) {
      // 确定用户类型，支持数字和字符串两种格式
      // role: 1=医生, 2=患者, 3=管理员
      if (userInfo.role === 1 || userInfo.user_type === 'doctor') {
        userType = 'doctor'
      } else if (userInfo.role === 2 || userInfo.user_type === 'patient') {
        userType = 'patient'
      } else if (userInfo.role === 3 || userInfo.user_type === 'admin') {
        userType = 'admin'
      } else {
        userType = 'patient' // 默认患者
      }
    }
    
    console.log('getLoginStatus - userType:', userType, 'role:', userInfo.role);
    
    return {
      isLoggedIn: !!isLoggedIn && !!token,
      userInfo: userInfo,
      token: token,
      userType: userType
    }
  } catch (e) {
    console.error('获取登录状态失败:', e)
    return {
      isLoggedIn: false,
      userType: 'patient',
      userInfo: {},
      token: ''
    }
  }
}

/**
 * 清除所有登录状态数据
 */
export function clearAllAuthData() {
  try {
    clearToken()
    clearUserInfo()
    saveLoginStatus(false)
    return true
  } catch (e) {
    console.error('清除登录状态失败:', e)
    return false
  }
}

/**
 * 登出函数
 */
export function logout() {
  const success = clearAllAuthData()
  if (success) {
    // 跳转到登录页面
    uni.redirectTo({
      url: '/pages/login/login'
    })
  }
  return success
}

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
export function isAuthenticated() {
  const { isLoggedIn } = getLoginStatus()
  return isLoggedIn
}

/**
 * 检查用户是否为医生
 * @returns {boolean} 是否为医生
 */
export function isDoctor() {
  const { userType } = getLoginStatus()
  return userType === 'doctor'
}

/**
 * 检查用户是否为患者
 * @returns {boolean} 是否为患者
 */
export function isPatient() {
  const { userType } = getLoginStatus()
  return userType === 'patient'
}

/**
 * 刷新用户信息
 * 注意：此函数需要传入从API获取的用户数据，不直接调用API
 * @param {Object} userData - 从API获取的用户数据
 * @returns {Promise<Object>} 更新后的用户信息
 */
export async function refreshUserInfo(userData) {
  try {
    if (!isAuthenticated()) {
      console.warn('刷新用户信息失败: 用户未登录');
      throw new Error('用户未登录');
    }

    console.log('开始刷新用户信息');
    
    // 检查传入的用户数据格式是否正确
    if (!userData || !userData.data) {
      console.error('刷新用户信息失败: 无效的用户数据格式', userData);
      throw new Error('获取用户信息失败: 无效的响应格式');
    }
    
    console.log('获取到用户信息:', userData.data);
    
    // 确保传入saveUserInfo的用户信息格式符合要求
    const normalizedUserData = {
      ...userData.data,
      // 确保微信相关字段映射正确
      wechat_name: userData.data.wechat_name || userData.data.nickname || '',
      wechat_avatar: userData.data.wechat_avatar || userData.data.avatar_url || '',
      // 确保身份证号字段映射正确
      id_card: userData.data.id_card || userData.data.idCard || '',
      // 添加角色信息标准化
      role: userData.data.role || (userData.data.user_type === 'doctor' ? 1 : 2)
    };
    
    console.log('标准化后的用户信息:', normalizedUserData);
    
    const saveResult = await saveUserInfo(normalizedUserData);
    if (!saveResult) {
      throw new Error('保存用户信息失败');
    }
    
    const refreshedUserInfo = getUserInfoLocal();
    console.log('用户信息刷新成功:', refreshedUserInfo);
    
    return refreshedUserInfo;
  } catch (error) {
    console.error('刷新用户信息失败:', error.message || error);
    throw error;
  }
}

/**
 * 执行完整登录流程的便捷方法
 * @param {Function} loginApiFunc - 登录API函数
 * @param {Object} loginParams - 登录参数
 * @returns {Promise<Object>} 登录结果
 */
export const doLogin = async (loginParams) => {
  try {
    // 检查登录参数是否完整
    if (!loginParams || !loginParams.identity) {
      throw new Error('登录参数不完整');
    }
    
    // 根据不同身份选择不同的登录方法
    let response;
    const { identity, wechat_code, ...restParams } = loginParams;
    
    // 判断是否为微信登录（含有wechat_code）
    const isWechatLogin = !!wechat_code;
    
    if (isWechatLogin) {
      // 微信登录流程
      const wechatParams = {
        code: wechat_code,
        identity: identity,
        ...restParams
      };
      
      response = await wechatLogin(wechatParams);
    } else {
      // 常规登录流程
      if (identity === 'patient') {
        response = await patientLogin(restParams);
      } else if (identity === 'doctor') {
        response = await doctorLogin(restParams);
      } else if (identity === 'admin') {
        response = await adminLogin(restParams);
      } else {
        throw new Error('不支持的用户身份');
      }
    }
    
    // 验证响应
    if (!response || !response.data) {
      throw new Error('无效的登录响应');
    }
    
    // 保存Token
    const token = response.data.token;
    if (token) {
      saveToken(token);
    }
    
    // 保存用户信息
    const userInfo = response.data.userInfo || response.data.user_info;
    if (userInfo) {
      saveUserInfo(userInfo, identity);
    }
    
    // 保存登录状态
    saveLoginStatus(true, identity);
    
    return {
      success: true,
      data: response.data,
      identity: identity
    };
  } catch (error) {
    console.error('登录失败:', error);
    return {
      success: false,
      error: error.message || '登录失败，请重试'
    };
  }
};

/**
 * 执行完整登出流程的便捷方法
 * @returns {boolean} 是否成功登出
 */
export function doLogout() {
  const success = clearAllAuthData();
  if (success) {
    console.log('登出成功，所有认证数据已清除');
    // 跳转到登录页面
    uni.redirectTo({
      url: '/pages/login/login'
    });
  } else {
    console.error('登出失败，部分认证数据可能未清除');
  }
  return success;
}